package ftp

import (
	"encoding/binary"
	"fmt"
	_func "gin/func"
	"gin/model"
	"os"
	"path/filepath"
	"sort"
	"strconv"
	"strings"
	"time"
	"unicode/utf16"
)

type DataParsing struct {
	dataIndexM      *model.DataIndexM
	dtaChatM        *model.DataChatM
	FtpConnectInfoM *model.FtpConnectInfo
	dataLoginM      *model.DataLoginM
	dataAdminM      *model.DataAdminM
	dataLockM       *model.DataLockM
	dataKillM       *model.DataKillM
	dataViolationsM *model.DataViolationsM
	dataTrapM       *model.DataTrapM
	dataFlagM       *model.DataFlagM
	dataBankM       *model.DataBankM
	dataEconomyM    *model.DataEconomyM
	ftpinfoM        *model.FtpInfo
	Log             *_func.StyleLog
	dataCarM        *model.DataCarM
	dataBoxM        *model.DataBoxM
	dataBunkerM     *model.DataBunkerM
	userDataS       *DataUserS
}

// NewDataParsing 构造函数
func NewDataParsing() *DataParsing {
	return &DataParsing{
		dataIndexM:      model.NewDataIndexM(),
		dtaChatM:        model.NewDataChatM(),
		FtpConnectInfoM: model.NewFtpConnectInfo(),
		dataLoginM:      model.NewDataLoginM(),
		dataAdminM:      model.NewDataAdminM(),
		dataLockM:       model.NewDataLockM(),
		dataKillM:       model.NewDataKillM(),
		dataViolationsM: model.NewDataViolationsM(),
		dataTrapM:       model.NewDataTrapM(),
		dataFlagM:       model.NewDataFlagM(),
		dataBankM:       model.NewDataBankM(),
		dataEconomyM:    model.NewDataEconomyM(),
		ftpinfoM:        model.NewFtpInfo(),
		dataCarM:        model.NewDataCarM(),
		dataBoxM:        model.NewDataBoxM(),
		dataBunkerM:     model.NewDataBunkerM(),
		userDataS:       NewDataUserS(),
		//Inject services
	}
}

type userData struct {
	userId    int64
	ip        string
	ftpInfoId int64
}

func (p *DataParsing) setLog(Log *_func.StyleLog) {
	p.Log = Log
}

// RunParsing 解析入口
func (p *DataParsing) RunParsing(user userData, scumFile []scumFile, UserData *[]model.DataUser) {

	fmt.Println("获取需要解析的文件")
	//_func.FtpLogGer("9", user)
	//fmt.Println(scumFile)

	p.Log.FtpLogGer("解析下载文件成功")
	fmt.Println("开始分类文件")
	scumFileMap, fileType := p.parsingFileType(scumFile)
	p.Log.FtpLogGer("分类文件结束")
	fmt.Println("分类文件结束")
	//fmt.Println(scumFileMap)
	//fmt.Println("获取文件索引", user)
	dataIndex := p.dataIndexM.GetUserDataIndex(user.userId, user.ftpInfoId)
	//fmt.Println("文件索引为", dataIndex)

	var useIndex model.DataIndex

	var svaeDataStatus = false //数据保存状态
	//循环解析所有文件分类
	for _, index := range fileType {
		p.Log.FtpLogGer2("解析分类为", index)
		fmt.Println("解析分类为:", index)
		useIndex = model.DataIndex{}
		//默认新增索引数据 下方遍历索引表 存在就不新增了
		var insert = true //是否创建新数据索引
		//获取当前类型文件的索引
		for _, indexM := range dataIndex {
			if index == indexM.DataType {
				useIndex = indexM
				insert = false
				break
			}
		}
		//文件过滤  未来为了方便新数据增加 在获取索引后 对文件时间和索引时间对比  过滤掉小于索引时间的文件

		//如果没有索引 就读取全部文件数据
		p.Log.FtpLogGer2("数据索引为", useIndex)
		fmt.Println("数据索引为:", useIndex)

		//用户数据
		//var newUserData []model.DataUser

		ftpInfoId := strconv.FormatInt(user.ftpInfoId, 10)
		p.Log.FtpLogGer2("ftpInfoId为:", ftpInfoId)
		switch index {
		case "login":
			//登录日志
			//文件排序
			scumFileMap["login"] = p.fileSort(scumFileMap["login"])
			//解析所有文件数据
			loginData, fileIndex, fileDataIndex := p.parsingLog(useIndex, scumFileMap["login"], ftpInfoId)
			if len(loginData) == 0 {
				//数据为空不用存数据
				break
			}
			//解析文本数据
			loginDataArr := p.parsingLoginLog(loginData, user.ftpInfoId)
			//解析数据存入数据库
			p.dataLoginM.InsertLoginData(loginDataArr)
			//保存数据索引
			//fmt.Print("是否插入数据", insert)
			p.dataIndexM.SaveUserDataIndex(user.userId, user.ftpInfoId, "login", int64(fileIndex), int64(fileDataIndex), insert)

			//用户登录数据处理
			p.userDataS.EventLoginDataUpdate(loginDataArr, UserData, user.ftpInfoId)

			//设定数据保存状态为真
			svaeDataStatus = true
			break
		case "admin":
			//管理员日志
			//文件排序
			scumFileMap["admin"] = p.fileSort(scumFileMap["admin"])
			//解析所有文件数据
			adminData, fileIndex, fileDataIndex := p.parsingLog(useIndex, scumFileMap["admin"], ftpInfoId)
			if len(adminData) == 0 {
				//数据为空不用存数据
				break
			}
			//解析文本数据
			adminDataArr := p.parsingAdminLog(adminData, user.ftpInfoId)

			//解析数据存入数据库
			p.dataAdminM.InsertDataAdmin(adminDataArr)
			//保存数据索引
			//fmt.Print("是否插入数据", insert)
			p.dataIndexM.SaveUserDataIndex(user.userId, user.ftpInfoId, "admin", int64(fileIndex), int64(fileDataIndex), insert)
			//设定数据保存状态为真
			svaeDataStatus = true
			break
		case "chat":
			//聊天日志
			//文件排序
			//p.Log.FtpLogGer(scumFileMap["chat"])
			scumFileMap["chat"] = p.fileSort(scumFileMap["chat"])
			//p.Log.FtpLogGer(scumFileMap["chat"])
			//解析文件
			catData, fileIndex, fileDataIndex := p.parsingLog(useIndex, scumFileMap["chat"], ftpInfoId)
			if len(catData) == 0 {
				break
			}
			//p.Log.FtpLogGer(scumFileMap["chat"])
			//分析数据
			catDataArr := p.parsingChatLog(catData, user.ftpInfoId, useIndex)
			p.Log.FtpLogGer(catDataArr)
			//存入数据库
			p.dtaChatM.InsertChatData(catDataArr)
			//保存索引
			//p.Log.FtpLogGer2("时间索引", fileIndex)
			p.dataIndexM.SaveUserDataIndex(user.userId, user.ftpInfoId, "chat", int64(fileIndex), int64(fileDataIndex), insert)
			svaeDataStatus = true
			break
		case "gameplay":

			//开锁日志
			switch index {

			//文件排序
			case "gameplay":
				scumFileMap["gameplay"] = p.fileSort(scumFileMap["gameplay"])

				//gameplay 文件包含多种数据所以要对索引单独处理
				insert = true
				useIndex = model.DataIndex{}
				for _, indexM := range dataIndex {
					fmt.Println("索引1", indexM)
					if "lock" == indexM.DataType {
						useIndex = indexM
						insert = false
						break
					}
				}
				fmt.Println("索引", useIndex)
				//解析所有文件数据

				lockData, fileIndex, fileDataIndex := p.parsingLog(useIndex, scumFileMap["gameplay"], ftpInfoId)
				if len(lockData) == 0 {
					//数据为空不用存数据
					break
				}
				//解析文本数据
				lockDataArr := p.parsingLockLog(lockData, user.ftpInfoId)

				//解析数据存入数据库
				p.dataLockM.InsertDataLock(lockDataArr)
				//保存数据索引
				//fmt.Print("是否插入数据", insert)
				p.dataIndexM.SaveUserUniqueDataIndex(user.userId, user.ftpInfoId, "lock", int64(fileIndex), int64(fileDataIndex), insert)
				//设定数据保存状态为真
				svaeDataStatus = true
			}
			//地雷日志
			switch index {
			case "gameplay":
				//地雷日志
				//文件排序
				scumFileMap["gameplay"] = p.fileSort(scumFileMap["gameplay"])

				//gameplay 文件包含多种数据所以要对索引单独处理
				insert = true
				useIndex = model.DataIndex{}
				for _, indexM := range dataIndex {
					if "trap" == indexM.DataType {
						useIndex = indexM
						insert = false
						break
					}
				}
				//解析所有文件数据
				trapData, fileIndex, fileDataIndex := p.parsingLog(useIndex, scumFileMap["gameplay"], ftpInfoId)
				if len(trapData) == 0 {
					//数据为空不用存数据
					break
				}

				//解析文本数据
				trapDataArr := p.parsingTrapLog(trapData, user.ftpInfoId)

				//解析数据存入数据库
				p.dataTrapM.InsertDataTrap(trapDataArr)
				//保存数据索引
				//fmt.Print("是否插入数据", insert)
				p.dataIndexM.SaveUserUniqueDataIndex(user.userId, user.ftpInfoId, "trap", int64(fileIndex), int64(fileDataIndex), insert)
				//设定数据保存状态为真
				svaeDataStatus = true
			}

			//领地旗日志
			switch index {

			case "gameplay":
				//文件排序
				scumFileMap["gameplay"] = p.fileSort(scumFileMap["gameplay"])
				//gameplay 文件包含多种数据所以要对索引单独处理
				insert = true
				useIndex = model.DataIndex{}
				for _, indexM := range dataIndex {
					if "flag" == indexM.DataType {
						useIndex = indexM
						insert = false
						break
					}
				}

				//解析所有文件数据
				flagData, fileIndex, fileDataIndex := p.parsingLog(useIndex, scumFileMap["gameplay"], ftpInfoId)
				if len(flagData) == 0 {
					//数据为空不用存数据
					break
				}
				//解析文本数据
				flagDataArr := p.parsingFlagLog(flagData, user.ftpInfoId)

				//解析数据存入数据库
				p.dataFlagM.InsertDataFlag(flagDataArr)
				//保存数据索引
				//fmt.Print("是否插入数据", insert)
				p.dataIndexM.SaveUserUniqueDataIndex(user.userId, user.ftpInfoId, "flag", int64(fileIndex), int64(fileDataIndex), insert)
				//设定数据保存状态为真
				svaeDataStatus = true
			}
			//case "gameplay":
			//地堡开门激活日志
			//文件排序
			/*
				scumFileMap["gameplay"] = p.fileSort(scumFileMap["gameplay"])
				//gameplay 文件包含多种数据所以要对索引单独处理
				insert = true
				useIndex = model.DataIndex{}
				for _, indexM := range dataIndex {
					if "bunker" == indexM.DataType {
						useIndex = indexM
						insert = false
						break
					}
				}

				//解析所有文件数据
				bunkerData, fileIndex, fileDataIndex := p.parsingLog(useIndex, scumFileMap["gameplay"], ftpInfoId)
				if len(bunkerData) == 0 {
					//数据为空不用存数据
					break
				}
				//解析文本数据
				bunkerDataArr := p.parsingBunkerLog(bunkerData, user.ftpInfoId)

				//解析数据存入数据库
				p.dataBunkerM.InsertDataBunker(bunkerDataArr)
				//保存数据索引
				//fmt.Print("是否插入数据", insert)
				p.dataIndexM.SaveUserUniqueDataIndex(user.userId, user.ftpInfoId, "bunker", int64(fileIndex), int64(fileDataIndex), insert)
				//设定数据保存状态为真
				svaeDataStatus = true
			*/
			break
		case "kill":
			//击杀日志
			//文件排序
			scumFileMap["kill"] = p.fileSort(scumFileMap["kill"])
			//解析所有文件数据
			killData, fileIndex, fileDataIndex := p.parsingLog(useIndex, scumFileMap["kill"], ftpInfoId)
			if len(killData) == 0 {
				//数据为空不用存数据
				break
			}
			//解析文本数据
			killDataArr := p.parsingKillLog(killData, user.ftpInfoId)

			//解析数据存入数据库
			p.dataKillM.InsertDataKill(killDataArr)
			//保存数据索引
			//fmt.Print("是否插入数据", insert)
			p.dataIndexM.SaveUserDataIndex(user.userId, user.ftpInfoId, "kill", int64(fileIndex), int64(fileDataIndex), insert)
			//设定数据保存状态为真
			svaeDataStatus = true
			break
		case "violations":
			//违规日志
			//文件排序
			scumFileMap["violations"] = p.fileSort(scumFileMap["violations"])
			//fmt.Println("违规文件组", scumFileMap["violations"])
			//fmt.Println("数据索引", useIndex)
			//解析所有文件数据
			violationsData, fileIndex, fileDataIndex := p.parsingLog(useIndex, scumFileMap["violations"], ftpInfoId)
			if len(violationsData) == 0 {
				//数据为空不用存数据
				break
			}
			//解析文本数据
			violationsDataArr := p.parsingViolationsLog(violationsData, user.ftpInfoId)

			//解析数据存入数据库
			p.dataViolationsM.InsertDataViolations(violationsDataArr)
			//保存数据索引
			//fmt.Print("是否插入数据", insert)
			p.dataIndexM.SaveUserDataIndex(user.userId, user.ftpInfoId, "violations", int64(fileIndex), int64(fileDataIndex), insert)
			//设定数据保存状态为真
			svaeDataStatus = true
			break
		case "economy":

			//银行日志
			switch index {
			case "economy":
				//文件排序
				scumFileMap["economy"] = p.fileSort(scumFileMap["economy"])
				insert = true
				useIndex = model.DataIndex{}
				for _, indexM := range dataIndex {
					fmt.Println("索引1", indexM)
					if "bank" == indexM.DataType {
						useIndex = indexM
						insert = false
						break
					}
				}

				//解析所有文件数据
				bankData, fileIndex, fileDataIndex := p.parsingLog(useIndex, scumFileMap["economy"], ftpInfoId)
				if len(bankData) == 0 {
					//数据为空不用存数据
					break
				}
				//解析文本数据
				bankDataArr := p.parsingBankLog(bankData, user.ftpInfoId)

				//解析数据存入数据库
				p.dataBankM.InsertDataBank(bankDataArr)
				//保存数据索引
				//fmt.Print("是否插入数据", insert)
				p.dataIndexM.SaveUserDataIndex(user.userId, user.ftpInfoId, "bank", int64(fileIndex), int64(fileDataIndex), insert)
				//设定数据保存状态为真
				svaeDataStatus = true

				p.userDataS.EventBankDataUpdate(bankDataArr, UserData)

			}

			//交易日志
			switch index {
			case "economy":
				//文件排序
				scumFileMap["economy"] = p.fileSort(scumFileMap["economy"])
				insert = true
				useIndex = model.DataIndex{}
				for _, indexM := range dataIndex {
					fmt.Println("索引1", indexM)
					if "trade" == indexM.DataType {
						useIndex = indexM
						insert = false
						break
					}
				}

				//解析所有文件数据
				economyData, fileIndex, fileDataIndex := p.parsingLog(useIndex, scumFileMap["economy"], ftpInfoId)
				if len(economyData) == 0 {
					//数据为空不用存数据
					break
				}
				//解析文本数据
				economyDataArr := p.parsingEconomyLog(economyData, user.ftpInfoId)

				//解析数据存入数据库
				p.dataEconomyM.InsertDataEconomy(economyDataArr)
				//保存数据索引
				//fmt.Print("是否插入数据", insert)
				p.dataIndexM.SaveUserDataIndex(user.userId, user.ftpInfoId, "trade", int64(fileIndex), int64(fileDataIndex), insert)
				//设定数据保存状态为真
				svaeDataStatus = true

				p.userDataS.EventEconomyDataUpdate(economyDataArr, UserData)
			}
			break
		case "vehicle_destruction":
			//汽车日志
			//文件排序
			scumFileMap["vehicle_destruction"] = p.fileSort(scumFileMap["vehicle_destruction"])
			//解析文件
			carData, fileIndex, fileDataIndex := p.parsingLog(useIndex, scumFileMap["vehicle_destruction"], ftpInfoId)
			if len(carData) == 0 {
				break
			}

			//分析数据
			carDataArr := p.parsingCarLog(carData, user.ftpInfoId)
			//存入数据库
			p.dataCarM.InsertDataCar(carDataArr)
			//保存索引
			//fmt.Println("数据保存状态", "vehicle_destruction", int64(fileIndex), int64(fileDataIndex), insert)

			p.dataIndexM.SaveUserDataIndex(user.userId, user.ftpInfoId, "vehicle_destruction", int64(fileIndex), int64(fileDataIndex), insert)
			svaeDataStatus = true
			break

		case "chest_ownership":
			//箱子日志
			//文件排序
			scumFileMap["chest_ownership"] = p.fileSort(scumFileMap["chest_ownership"])
			//解析文件
			boxData, fileIndex, fileDataIndex := p.parsingLog(useIndex, scumFileMap["chest_ownership"], ftpInfoId)
			if len(boxData) == 0 {
				break
			}

			//分析数据
			boxDataArr := p.parsingBoxLog(boxData, user.ftpInfoId)
			//存入数据库
			p.dataBoxM.InsertDataBox(boxDataArr)
			//保存索引

			p.dataIndexM.SaveUserDataIndex(user.userId, user.ftpInfoId, "chest_ownership", int64(fileIndex), int64(fileDataIndex), insert)
			svaeDataStatus = true
			break
		default:
			fmt.Println("没有读取的类型", index)
		}
	}
	p.userDataS.EventSaveUserData(user.ftpInfoId, UserData)

	p.Log.FtpLogGer("数据处理结束")
	//保存数据时间 和 数据解析索引时间
	p.FtpConnectInfoM.SaveDataUpdatedTime(user.ftpInfoId, svaeDataStatus)
	p.ftpinfoM.SaveDataUpdatedTime(user.ftpInfoId)

}

// 文件分类
func (p *DataParsing) parsingFileType(scumFileList []scumFile) (map[string][]scumFile, []string) {

	var scumFileArr = make(map[string][]scumFile)

	var fileType []string
	for _, file := range scumFileList {
		fileInfo := file.name
		lastIndex := strings.LastIndex(fileInfo, "_")
		if lastIndex == -1 {
			continue
		}
		prefix := fileInfo[:lastIndex]
		suffix := fileInfo[lastIndex+1:]
		fileTime := strings.Split(suffix, ".")
		file.fileName = prefix
		file.fileTime = fileTime[0]

		//获取下载文件的所有分类
		if !contains(fileType, prefix) {
			fileType = append(fileType, prefix)
		}

		switch prefix {
		case "login":

			scumFileArr["login"] = append(scumFileArr["login"], file)
			break
		case "admin":

			scumFileArr["admin"] = append(scumFileArr["admin"], file)
			break
		case "violations":

			scumFileArr["violations"] = append(scumFileArr["violations"], file)
			break
		case "vehicle_destruction":

			scumFileArr["vehicle_destruction"] = append(scumFileArr["vehicle_destruction"], file)
			break
		case "raid_protection":

			scumFileArr["raid_protection"] = append(scumFileArr["raid_protection"], file)
			break
		case "loot":
			scumFileArr["loot"] = append(scumFileArr["loot"], file)
			break
		case "kill":

			scumFileArr["kill"] = append(scumFileArr["kill"], file)
			break
		case "gameplay":

			scumFileArr["gameplay"] = append(scumFileArr["gameplay"], file)
			break
		case "famepoints":

			scumFileArr["famepoints"] = append(scumFileArr["famepoints"], file)
			break
		case "event_kill":

			scumFileArr["event_kill"] = append(scumFileArr["event_kill"], file)
			break
		case "chest_ownership":

			scumFileArr["chest_ownership"] = append(scumFileArr["chest_ownership"], file)
			break
		case "chat":

			scumFileArr["chat"] = append(scumFileArr["chat"], file)
			break
		case "economy":
			scumFileArr["economy"] = append(scumFileArr["economy"], file)
			break
		}

	}
	//把登录数据放在最前面  最优先解析 防止用户数据出现 先解析其他类型用户数据 后解析用户数据
	fileType = moveToFront(fileType, "login")

	return scumFileArr, fileType
}

// 解析每个文件
func (p *DataParsing) parsingLog(index model.DataIndex, scumFileArr []scumFile, ftpInfoId string) ([]string, int, int) {
	fmt.Println("开始解析文件")
	var fileTime, fileRow int

	// 初始化索引时间和行数
	if index.Id != 0 {
		fileTime = int(index.FileTime)
		fileRow = int(index.FileRow)
	}

	var logData []string
	finalTimestamp := fileTime // 最终返回的文件时间戳
	finalFileRow := fileRow    // 最终返回的文件行索引

	// 没有文件时直接返回
	if len(scumFileArr) == 0 {
		return nil, finalTimestamp, finalFileRow
	}

	for fileIdx, file := range scumFileArr {

		//采用文件时间索引+ 文件行索引 方式分析数据

		//文件大小等于 0 过滤
		if file.size == 0 {
			continue
		}

		// 使用固定的时间格式进行解析
		//fmt.Println("文件时间", file.fileTime)
		t, err := time.Parse("20060102150405", file.fileTime)
		if err != nil {
			fmt.Printf("解析文件时间失败，文件: %s, 错误: %v\n", file.fileTime, err)
			continue // 跳过无法解析时间的文件
		}
		// 转换为 Unix 时间戳（秒）
		currentTimestamp := int(t.Unix())

		// 忽略时间早于当前索引的文件
		if currentTimestamp < fileTime {
			continue
		}

		log := p.ReadLog(file, ftpInfoId)

		// 过滤前两行（防止越界）
		if len(log) >= 2 {
			log = log[2:]
		} else {
			continue
		}

		// 处理当前文件内容

		if currentTimestamp > fileTime {
			// 新时间戳文件：全量处理并更新索引
			logData = append(logData, log...)
			finalTimestamp = currentTimestamp
			finalFileRow = len(log)
		} else if currentTimestamp == fileTime {
			// 相同时间戳文件：增量处理
			startPos := fileRow
			if startPos < 0 {
				startPos = 0
			}
			if startPos > len(log) {
				startPos = len(log)
			}
			processedLog := log[startPos:]
			logData = append(logData, processedLog...)
			finalFileRow = len(log) // 更新为当前文件总行数
		}

		// 更新最终时间戳（确保最后一个有效文件的时间）
		if currentTimestamp >= finalTimestamp {
			finalTimestamp = currentTimestamp
		}

		// 如果是最后一个文件且时间未更新，保留finalFileRow
		if fileIdx == len(scumFileArr)-1 && currentTimestamp == finalTimestamp {
			finalFileRow = len(log)
		}
	}
	return logData, finalTimestamp, finalFileRow
}

// ReadLog 解析单个文件数据
func (p *DataParsing) ReadLog(file scumFile, ftpInfoId string) []string {
	data, err := p.ReadLinesFromStart(file.name, ftpInfoId)
	if err != nil {
		panic(err)
		//fmt.Println("读取文件错误：", err)
	}
	return data
}

// ReadLinesFromStart 解析日志数据算法
func (p *DataParsing) ReadLinesFromStart(filename string, ftpInfoId string) ([]string, error) {
	// 打开文件

	scumFtpDir := "public/ftpLog/log_" + ftpInfoId
	d, _ := os.Getwd()

	file, err := os.ReadFile(filepath.Join(d, scumFtpDir+"/"+filename))

	if err != nil {
		return nil, fmt.Errorf("无法打开文件: %v", err)
	}
	//defer file.Close()

	/*scanner := bufio.NewScanner(file)*/
	//fmt.Println("转换前数据")
	//fmt.Println(file)
	data, err := UCS2LEToUTF8(file)
	//fmt.Println("转换后数据")
	//fmt.Println(data)

	lines := strings.Split(data, "\n")

	return lines, err

}

// UCS2LEToUTF8 编码转换
func UCS2LEToUTF8(ucs2leBytes []byte) (string, error) {
	// 校验字节序列长度是否为偶数
	if len(ucs2leBytes)%2 != 0 {
		return "", fmt.Errorf("输入的字节序列长度不是偶数，无法解析为 UCS-2 Little Endian 编码")
	}

	// 将 UCS-2 Little Endian 解码为 UTF-16
	var utf16Data []uint16
	for i := 0; i < len(ucs2leBytes); i += 2 {
		u16 := binary.LittleEndian.Uint16(ucs2leBytes[i:])
		utf16Data = append(utf16Data, u16)
	}

	// 转换 UTF-16 到 UTF-8
	r := utf16.Decode(utf16Data)
	utf8Str := string(r)

	return utf8Str, nil
}

// 文件排序
func (p *DataParsing) fileSort(scumFileMap []scumFile) []scumFile {
	//文件基于时间排序  文件数大于1时处理
	chatFiles := scumFileMap
	if len(chatFiles) > 1 {

		sort.SliceStable(chatFiles, func(i, j int) bool {

			fileTimeA, _ := strconv.Atoi(chatFiles[i].fileTime)
			fileTimeB, _ := strconv.Atoi(chatFiles[j].fileTime)
			return fileTimeA < fileTimeB
		})
	}
	return chatFiles
}

// 判断切片中是否包含指定元素
func contains(slice []string, element string) bool {
	for _, item := range slice {
		if item == element {
			return true
		}
	}
	return false
}

// 移动数值指定值在最前面
func moveToFront(slice []string, value string) []string {
	// 查找值的位置
	for i, v := range slice {
		if v == value {
			// 如果找到，交换到最前面
			slice[i], slice[0] = slice[0], slice[i]
			return slice
		}
	}
	// 如果没有找到，返回原切片
	return slice
}
